/*
 * @Author: Qzzz 2832160409@qq.com
 * @Date: 2024-09-27 08:09:41
 * @LastEditors: Qzzz 2832160409@qq.com
 * @LastEditTime: 2024-09-29 12:32:01
 * @FilePath: \bishe\后端\routes\category.js
 * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 */
// 用户路由单元
var express = require('express');
var router = express.Router();
// 导入连接池对象
const sql = require('../db/index')
// 引入jwt
const jwt = require('jsonwebtoken')

// 引入响应体
const Response = require('../utils/response')


// 获取栏目的接口
router.get('/findAll', async (req, res) => {
  const [response] = await sql.query('select * from category')
  console.log(response);

  res.send(new Response(200, '查询成功', response))
})

router.post('/saveOrUpdate', async (req, res) => {
  // 解析请求体中的数据
  const { id, name, description } = req.body;

  try {
    if (id) {
      // 如果存在id，则执行更新操作
      const updateSql = `
        UPDATE category
        SET name = ?, description = ?
        WHERE id = ?
      `;
      const [updateResult] = await sql.query(updateSql, [name, description, id]);
      res.send(new Response(200, '更新成功', null));
    } else {
      // 如果不存在id，则执行新增操作
      const insertSql = `
        INSERT INTO category (name, description)
        VALUES (?, ?)
      `;
      const [insertResult] = await sql.query(insertSql, [name, description]);
      res.send(new Response(200, '新增成功', null));
    }
  } catch (error) {
    // 错误处理
    res.send(new Response(500, '操作失败', error.message));
  }
});


// 获取文章的接口查询的接口
router.get('/findCategoryArticles', async (req, res) => {
  try {
    // 查询所有类别
    const [categories] = await sql.query('SELECT * FROM category');
    // 准备最终结果数组
    const result = [];
    // 遍历每个类别
    for (const category of categories) {
      try {
        // 查询该类别下的文章，利用外键关联查询
        const [articles] = await sql.query('SELECT ca.* FROM category_article ca JOIN category c ON ca.category_id = c.id WHERE c.id =?', [category.id]);
        // 将类别和文章数据添加到结果数组
        result.push({
          category: category,
          articles: articles
        });
      } catch (error) {
        // 如果查询文章时出错，仍然将类别添加到结果数组，但文章为空数组
        console.error('Error fetching articles for category:', category.id, error);
        result.push({
          category: category,
          articles: []
        });
      }
    }
    // 返回结果
    res.send(new Response(200, '获取成功', result));
  } catch (error) {
    // 处理查询类别时的错误
    console.error('Error fetching categories:', error);
    res.send(new Response(500, '文章错误查询', null));
  }
});


router.get('/pageQuery', async (req, res) => {
  const { id, page, pageSize } = req.query; // 从请求中获取参数
  const offset = (page - 1) * pageSize; // 计算偏移量

  try {
    // 查询指定ID的类别
    const [category] = await sql.query('SELECT * FROM category WHERE id = ?', [id]);
    if (category.length === 0) {
      // 如果没有找到类别，返回404
      return res.status(404).send(new Response(404, '类别未找到', null));
    }

    try {
      // 查询该类别下的文章，利用外键关联查询，并应用分页
      const [articles] = await sql.query(
        'SELECT ca.* FROM category_article ca JOIN category c ON ca.category_id = c.id WHERE c.id = ? LIMIT ? OFFSET ?',
        [id, parseInt(pageSize, 10), parseInt(offset, 10)]
      );
      // 返回结果
      res.send(new Response(200, '获取成功', {
        category: category[0],
        articles: articles
      }));
    } catch (error) {
      // 如果查询文章时出错，返回错误信息
      console.error('Error fetching articles for category:', id, error);
      res.send(new Response(500, '文章查询错误', null));
    }
  } catch (error) {
    // 处理查询类别时的错误
    console.error('Error fetching category:', id, error);
    res.send(new Response(500, '类别查询错误', null));
  }
});



router.get('/pageQueryFind', async (req, res) => {
  // 从请求的查询字符串中获取参数
  const { categoryId, title, author, page, pageSize } = req.query; 
  // 计算分页的偏移量，用于SQL查询中的OFFSET
  const offset = (page - 1) * pageSize; 

  // 初始化一个数组来存储构建SQL条件的片段
  const condition = [];
  // 初始化一个数组来存储与条件片段相对应的值
  const values = [];

  // 如果请求中包含categoryId参数，则添加一个条件片段和对应的值
  if (categoryId) {
    condition.push('category_id = ?');
    values.push(categoryId);
  }
  // 如果请求中包含title参数，则添加一个条件片段和对应的值
  if (title) {
    condition.push('title like ?');
    values.push(`%${title}%`);
  }
  // 如果请求中包含author参数，则添加一个条件片段和对应的值
  if (author) {
    condition.push('author like ?');
    values.push(`%${author}%`);
  }

  // 根据条件片段数组的长度，构建完整的SQL条件字符串
  let sqlStr = condition.length ? `WHERE ${condition.join(' AND ')}` : '';
  // 打印构建的SQL条件字符串到控制台
  console.log(sqlStr);

  try {
    // 使用内连接（INNER JOIN）来联合category_article表，并根据构建的条件进行筛选
    // LIMIT和OFFSET用于实现分页功能
    const [articles] = await sql.query(
      `SELECT * FROM category_article ${sqlStr} LIMIT ? OFFSET ?`,
      // 将条件片段的值和分页参数一起传递给SQL查询
      [...values, parseInt(pageSize, 10), parseInt(offset, 10)]
    );

    // 为了获取符合条件的文章总数，执行另一个SQL查询
    // 这个查询和获取文章列表的查询类似，但不包括LIMIT和OFFSET
    const [totalCount] = await sql.query(
      `SELECT count(*) as count FROM category_article ${sqlStr}`,
      values
    );
    // 从查询结果中获取总数
    const total = totalCount[0].count;

    // 如果查询成功，发送一个包含文章列表、总数、当前页和每页大小的响应
    res.send({
      status: 200,
      message: '获取成功',
      data: {
        list: articles, // 将查询到的文章列表赋值给list属性
        total: total,
        page: parseInt(page),
        pageSize: parseInt(pageSize)
      }
    });
  } catch (error) {
    // 如果在查询过程中发生错误，打印错误信息到控制台
    console.error('Error fetching articles:', error);
    // 发送一个包含错误信息的响应
    res.status(500).send({
      status: 500,
      message: '文章查询错误',
      data: null
    });
  }
});

// 删除数据的接口
router.get('/deleteById', async (req, res) => {
  const { id } = req.query;
  try {
    // 使用连接池执行查询
    await sql.query('DELETE FROM category WHERE id = ?', [id]);
    // 返回成功响应
    res.send(new Response(200, '删除成功', null))
  } catch (error) {
    // 处理可能的错误
    res.send(new Response(500, '删除失败', null))
  }
});
module.exports = router;